Page({
  data: {
    todayCourses: [],
    currentTime: '', // 当前时间
    todayDate: '', // 今天的日期
    isLogin: false,
    userInfo: null,
    showLoginForm: false,
    showRegisterForm: false,
    currentDate: '',
    loginForm: {
      username: '',
      password: ''
    },
    registerForm: {
      username: '',
      password: '',
      confirmPassword: '',
      teacherName: '',
      phone: ''
    },
    showDebugMode: false  // 添加调试模式标志
  },

  onLoad() {
    this.setCurrentDate()
    this.checkLoginStatus()
    this.fetchTodayCourses()
    this.getCurrentTime()
  },

   // 添加 onShow 生命周期函数，每次页面显示时刷新数据
   onShow() {
    // 检查登录状态，可能在其他页面已经登录或退出
    this.checkLoginStatus()
    
    // 如果已登录，刷新今日课程数据
    if (this.data.isLogin) {
      // 刷新今日课程数据
      this.fetchTodayCourses()
      
      // 更新当前时间
      this.getCurrentTime()
      
      // 更新日期显示（以防跨天使用）
      this.setCurrentDate()
      
      console.log('[个人中心] 页面显示，刷新数据')
    }
  },
  getCurrentTime: function() {
    const date = new Date();
    this.setData({
      currentTime: date.getHours() * 60 + date.getMinutes() // 转换为分钟
    });
  },
  // 跳转到课程表
  goToSchedule() {
    wx.switchTab({
      url: '/pages/schedule/schedule',
      fail: (err) => {
        console.error('跳转失败：', err)
        wx.showToast({
          title: '页面跳转失败',
          icon: 'none'
        })
      }
    })
  },
  // 跳转到个人设置
goToSettings() {
  wx.navigateTo({
    url: '/pages/settings/settings'
  })
},
   // 设置当前日期
   setCurrentDate() {
    const now = new Date()
    const weekdays = ['周一', '周二', '周三', '周四', '周五', '周六','周日', ]
    const date = `${now.getMonth() + 1}月${now.getDate()}日 ${weekdays[now.getDay()-1]}`
    this.setData({ currentDate: date })
  },
  // 检查登录状态
  checkLoginStatus() {
    const teacherId = wx.getStorageSync('teacherId')
    const userInfo = wx.getStorageSync('userInfo')
    
    if (teacherId && userInfo) {
      this.setData({
        isLogin: true,
        userInfo: userInfo
      })
    }
  },

  // 显示登录表单
  showLogin() {
    this.setData({
      showLoginForm: true,
      showRegisterForm: false
    })
  },
  // 订阅课程提醒 - 简化为本地提醒
  subscribeReminder() {
    console.info('[个人中心] 开始设置课程提醒');
    
    // 直接保存提醒状态，不再请求微信订阅消息
    this.saveSubscriptionStatus();
    
    wx.showToast({
      title: '课程提醒已开启',
      icon: 'success'
    });
  },
  
  // 保存订阅状态到服务器
  saveSubscriptionStatus() {
    const app = getApp();
    const db = app.getDB();
    const teacherId = wx.getStorageSync('teacherId');
    
    // 更新教师的订阅状态
    db.collection('teachers').doc(teacherId).update({
      data: {
        hasSubscribed: true,
        subscribeTime: db.serverDate(),
        useLocalNotification: true // 标记使用本地通知而非订阅消息
      }
    }).then(() => {
      console.log('提醒状态已保存');
    }).catch(err => {
      console.error('保存提醒状态失败:', err);
    });
    
    // 为今日所有课程设置提醒
    this.data.todayCourses.forEach(course => {
      this.setupCourseReminder(course);
    });
  },
  

    // 设置课程提醒 - 修改为本地提醒  -只在课程开始前的指定时间点提醒一次 - 对于已经过了提醒时间点但课程还未开始的情况，不再设置提醒
    // 系统检查时会将已过期的提醒标记为"expired"而不是发送提醒
    setupCourseReminder(course) {
      const app = getApp();
      const db = app.getDB();
      const teacherId = wx.getStorageSync('teacherId');
      
      // 计算提醒时间
      const reminderMinutes = this.parseReminderTime(course.reminderTime || '10分钟');
      const courseStartTime = this.parseTimeToMinutes(course.startTime);
      
      // 获取当前时间（分钟数）
      const now = new Date();
      const currentMinutes = now.getHours() * 60 + now.getMinutes();
      
      // 计算应该提醒的时间点（课程开始前n分钟）
      const reminderTimePoint = courseStartTime - reminderMinutes;
      
      // 如果提醒时间已经过了，则不设置提醒
      if (currentMinutes >= courseStartTime) {
        console.log(`课程 ${course.courseName} 已经开始，不设置提醒`);
        return;
      }
      
      // 如果提醒时间已过但课程还未开始，也不设置提醒
      if (currentMinutes >= reminderTimePoint) {
        console.log(`课程 ${course.courseName} 的提醒时间已过，不设置提醒`);
        return;
      }
      
      // 计算提醒的具体时间
      const reminderDate = new Date();
      const reminderHours = Math.floor(reminderTimePoint / 60);
      const reminderMins = reminderTimePoint % 60;
      reminderDate.setHours(reminderHours, reminderMins, 0, 0);
      
      // 创建本地提醒记录
      db.collection('reminders').add({
        data: {
          courseId: course._id,
          courseName: course.courseName,
          startTime: course.startTime,
          classroom: course.classroom,
          weekday: course.weekday,
          weekdayName: this.getWeekdayName(course.weekday),
          reminderTime: course.reminderTime || '10分钟',
          reminderContent: `您的课程"${course.courseName}"即将在${course.classroom}开始`,
          teacherId: teacherId,
          createTime: db.serverDate(),
          reminderDateTime: reminderDate,
          status: 'pending',
          useLocalNotification: true
        }
      }).then(res => {
        console.log('本地提醒设置成功:', res);
        console.log(`课程 ${course.courseName} 将在 ${reminderDate.toLocaleTimeString()} 提醒`);
      }).catch(err => {
        console.error('设置本地提醒失败:', err);
      });
    },
  
  // 解析提醒时间（如"10分钟"转为10）
  parseReminderTime(reminderTimeStr) {
    const match = reminderTimeStr.match(/(\d+)/);
    return match ? parseInt(match[1]) : 10; // 默认10分钟
  },
  
  // 将时间字符串转换为分钟数（如"08:30"转为510）
  parseTimeToMinutes(timeStr) {
    const [hours, minutes] = timeStr.split(':').map(Number);
    return hours * 60 + minutes;
  },
  
  // 获取星期几的名称
  getWeekdayName(weekday) {
    const weekdays = ['周日', '周一', '周二', '周三', '周四', '周五', '周六'];
    return weekdays[parseInt(weekday)];
  },
  
  // 创建测试提醒 - 简化版
    // 创建测试提醒 - 简化版
    createTestReminder: async function() {
      try {
        const app = getApp();
        const db = app.getDB();
        const teacherId = wx.getStorageSync('teacherId');
        
        if (!teacherId) {
          wx.showToast({
            title: '请先登录',
            icon: 'none'
          });
          return;
        }
        
        wx.showLoading({ title: '创建测试提醒...' });
        
        // 创建一个5秒后触发的测试提醒
        const now = new Date();
        const reminderTime = new Date(now.getTime() + 5 * 1000); // 5秒后
        const courseStartTime = new Date(now.getTime() + 10 * 60 * 1000); // 10分钟后课程开始
        
        const formattedStartTime = `${courseStartTime.getHours()}:${courseStartTime.getMinutes() < 10 ? '0' + courseStartTime.getMinutes() : courseStartTime.getMinutes()}`;
        
        const result = await db.collection('reminders').add({
          data: {
            courseId: 'test_course_id',
            courseName: '测试课程',
            startTime: formattedStartTime,
            classroom: '测试教室',
            weekday: now.getDay(),
            weekdayName: ['周日','周一','周二','周三','周四','周五','周六'][now.getDay()],
            timeSlot: 0,
            reminderTime: '提前10分钟',
            reminderContent: '这是一条测试提醒',
            teacherId: teacherId,
            reminderDateTime: reminderTime,
            createTime: db.serverDate(),
            status: 'pending',
            isTestReminder: true,
            useLocalNotification: true // 使用本地通知
          }
        });
        
        // 设置一个定时器，5秒后显示提醒
        setTimeout(() => {
          this.showLocalNotification({
            courseName: '测试课程',
            startTime: formattedStartTime,
            classroom: '测试教室',
            content: '这是一条测试提醒（课程将在10分钟后开始）'
          });
        }, 5000);
        
        wx.hideLoading();
        wx.showToast({
          title: '测试提醒已创建',
          icon: 'success'
        });
        
        console.info('[调试] 创建了测试提醒:', {
          id: result._id,
          reminderTime: reminderTime.toLocaleString(),
          courseStartTime: courseStartTime.toLocaleString(),
          timeLeft: '5秒后触发提醒，课程将在10分钟后开始'
        });
        
      } catch (err) {
        wx.hideLoading();
        console.error('[调试] 创建测试提醒失败:', err);
        wx.showToast({
          title: '创建失败: ' + err.message,
          icon: 'none'
        });
      }
    },
  
  // 显示本地通知
  showLocalNotification(reminder) {
    // 使用微信原生弹窗显示提醒
    wx.showModal({
      title: '课程提醒',
      content: `${reminder.courseName}\n时间: ${reminder.startTime}\n地点: ${reminder.classroom}\n${reminder.content || '即将开始，请做好准备'}`,
      showCancel: false,
      confirmText: '我知道了'
    });
    
    // 同时播放提示音
    const innerAudioContext = wx.createInnerAudioContext();
    innerAudioContext.src = '/assets/sounds/notification.mp3'; // 需要准备一个提示音文件
    innerAudioContext.play();
  },
  debugReminder: function() {
    console.info('[调试] 开始调试提醒系统');
    
    // 直接创建测试提醒
    this.createTestReminder();
    
    // 手动检查提醒
    const app = getApp();
    if (typeof app.checkReminders === 'function') {
      app.checkReminders();
    } else {
      console.error('[调试] app.checkReminders 不是一个函数');
      wx.showToast({
        title: '提醒检查失败',
        icon: 'none'
      });
    }
    
    wx.showToast({
      title: '正在调试提醒系统',
      icon: 'none'
    });
  },
    // 切换调试模式
    toggleDebugMode() {
      // 连续点击头像或某个区域5次可以触发
      if (!this.tapCount) this.tapCount = 0;
      this.tapCount++;
      
      if (this.tapCount >= 5) {
        this.tapCount = 0;
        this.setData({
          showDebugMode: !this.data.showDebugMode
        });
        
        wx.showToast({
          title: this.data.showDebugMode ? '已开启调试模式' : '已关闭调试模式',
          icon: 'none'
        });
      }
      
      // 5秒后重置点击计数
      if (this.resetTimer) clearTimeout(this.resetTimer);
      this.resetTimer = setTimeout(() => {
        this.tapCount = 0;
      }, 5000);
    },
  
  // 设置课程提醒
  setupCourseReminder(course) {
    // 这里需要调用云函数来设置定时提醒
    // 云函数会在指定时间通过微信API发送订阅消息
    wx.cloud.callFunction({
      name: 'setupReminder',
      data: {
        courseId: course._id,
        courseName: course.courseName,
        startTime: course.startTime,
        classroom: course.classroom,
        reminderTime: course.reminderTime || '1小时', // 默认提前1小时
        teacherId: wx.getStorageSync('teacherId')
      }
    }).then(res => {
      console.log('提醒设置成功:', res);
    }).catch(err => {
      console.error('设置提醒失败:', err);
    });
  },
  // 显示注册表单
  showRegister() {
    this.setData({
      showLoginForm: false,
      showRegisterForm: true
    })
  },
  //显示今日课程
  fetchTodayCourses: async function() {
    try {
      const weekday = new Date().getDay()-1; // 获取当前星期几，保持为数字
      const teacherId = wx.getStorageSync('teacherId'); // 从缓存中获取当前登录教师的ID
      console.log('weekday',weekday)
      // 修改后
      const app = getApp();
      const db = app.getDB();
      
      // 查询所有课程数据
      const { data } = await db.collection('courses').where({
          teacherId: teacherId
      }).get();

      console.log('所有课程数据:', data); // 输出所有课程数据以便调试

      // 筛选出今天的课程
      const todayCourses = data.filter(course => {
          console.log('isTrue?',course.weekday === weekday || course.weekday === weekday.toString());
          return course.weekday === weekday || course.weekday === weekday.toString();
      });
      console.log('todayCoursesj:',todayCourses)
      // 设置今日课程
      this.setData({
          todayCourses: todayCourses
      });
    

    } catch (err) {
        console.error('查询今日课程失败：', err);
        wx.showToast({
            title: '查询失败',
            icon: 'none'
        });
    }
},
  // 处理登录表单输入
  onLoginInput(e) {
    const { field } = e.currentTarget.dataset
    this.setData({
      [`loginForm.${field}`]: e.detail.value
    })
  },

  // 处理注册表单输入
  onRegisterInput(e) {
    const { field } = e.currentTarget.dataset
    this.setData({
      [`registerForm.${field}`]: e.detail.value
    })
  },

  // 处理登录
  async handleLogin() {
    try {
      const { username, password } = this.data.loginForm
      
      if (!username || !password) {
        wx.showToast({
          title: '请填写完整信息',
          icon: 'none'
        })
        return
      }

      wx.showLoading({
        title: '登录中...'
      })

      const app = getApp();
      const db = app.getDB();
      // 查询用户信息
      const { data } = await db.collection('teachers').where({
        username: username,
        password: password  // 实际应用中应该使用加密密码
      }).get()

      if (data.length === 0) {
        throw new Error('用户名或密码错误')
      }

      const userInfo = data[0]

      // 存储用户信息
      wx.setStorageSync('teacherId', userInfo._id)
      wx.setStorageSync('userInfo', userInfo)

      this.setData({
        isLogin: true,
        userInfo: userInfo,
        showLoginForm: false
      })

      wx.hideLoading()
      wx.showToast({
        title: '登录成功',
        icon: 'success'
      })

    } catch (err) {
      console.error('登录失败：', err)
      wx.hideLoading()
      wx.showToast({
        title: err.message || '登录失败',
        icon: 'none'
      })
    }
  },

  // 处理注册
  async handleRegister() {
    try {
      const form = this.data.registerForm
      
      // 表单验证
      if (!form.username || !form.password || !form.confirmPassword || 
          !form.teacherName || !form.phone) {
        wx.showToast({
          title: '请填写完整信息',
          icon: 'none'
        })
        return
      }

      if (form.password !== form.confirmPassword) {
        wx.showToast({
          title: '两次密码不一致',
          icon: 'none'
        })
        return
      }

      wx.showLoading({
        title: '注册中...'
      })

      const app = getApp();
      const db = app.getDB(); // 替换原有wx.cloud.database调用

      // 检查用户名是否已存在
      const { data } = await db.collection('teachers').where({
        username: form.username
      }).get()

      if (data.length > 0) {
        throw new Error('用户名已存在')
      }

      // 创建新用户
      const result = await db.collection('teachers').add({
        data: {
          username: form.username,
          password: form.password,  // 实际应用中应该使用加密密码
          teacherName: form.teacherName,
          phone: form.phone,
          createTime: db.serverDate(),
          avatarUrl: '/assets/images/default-avatar.png'
        }
      })

      wx.hideLoading()
      wx.showToast({
        title: '注册成功',
        icon: 'success'
      })

      // 注册成功后自动登录
      this.setData({
        loginForm: {
          username: form.username,
          password: form.password
        },
        showRegisterForm: false,
        showLoginForm: true
      })

    } catch (err) {
      console.error('注册失败：', err)
      wx.hideLoading()
      wx.showToast({
        title: err.message || '注册失败',
        icon: 'none'
      })
    }
  },

  // 处理退出登录
  handleLogout() {
    wx.showModal({
      title: '提示',
      content: '确定要退出登录吗？',
      success: (res) => {
        if (res.confirm) {
          const cleanupKeys = [
            'teacherId', 
            'userInfo',
            'todayCourses',
            'courseList',
            'studentList',
            'attendanceRecords',
            'classInfo',
            'performanceData'
          ];
          
          // 清理固定键值
          cleanupKeys.forEach(key => wx.removeStorageSync(key));
          
          // 清理动态生成的缓存键（如考勤周数据）
          const storageInfo = wx.getStorageInfoSync();
          storageInfo.keys.forEach(key => {
            if (key.startsWith('attendance_') || 
                key.startsWith('studentList_') ||
                key.startsWith('performance_')) {
              wx.removeStorageSync(key);
            }
          });
        
          // 更新登录状态
          this.setData({
            isLogin: false,
            userInfo: null,
            todayCourses: []
          });
        }
      }
    })
  }
})